package org.aynu.cartservice.service.Impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.aynu.cartservice.common.CartConstants;
import org.aynu.cartservice.mapper.CartItemsMapper;
import org.aynu.cartservice.mapper.CartMapper;
import org.aynu.cartservice.model.CartDTO;
import org.aynu.cartservice.model.CartItems;
import org.aynu.cartservice.model.Carts;
import org.aynu.cartservice.service.CartService;
import org.aynu.cartservice.common.CartResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * 购物车服务实现
 *
 * @author 小粥
 * @since 2025/03/03
 */
@Service
@Slf4j
public class CartServiceImpl extends ServiceImpl<CartMapper, Carts> implements CartService {
    private final CartItemsMapper cartItemsMapper;

    @Autowired
    public CartServiceImpl(CartItemsMapper cartItemsMapper) {
        this.cartItemsMapper = cartItemsMapper;
    }

    private Carts getCartByUserId(int userId) {
        return this.lambdaQuery()
                .eq(Carts::getUserId, userId)
                .one();
    }

    @Override
    public CartResponse<Integer> createCart(int userId) {
        try {
            Carts existingCart = getCartByUserId(userId);
            if (existingCart != null) {
                return CartResponse.error(CartConstants.ERROR_CART_EXISTS);
            }

            Carts newCart = new Carts();
            newCart.setUserId(userId);
            boolean result = this.save(newCart);
            if (!result) {
                return CartResponse.error(CartConstants.ERROR_CREATE_CART);
            }

            return CartResponse.success(CartConstants.SUCCESS_CREATE_CART, newCart.getCartId());
        } catch (Exception e) {
            log.error("创建购物车时发生异常：{}", e.getMessage(), e);
            return CartResponse.error(CartConstants.ERROR_SERVER + e.getMessage());
        }
    }

    @Override
    public CartResponse<Integer> selectCartId(int userId) {
        try {
            Carts cart = getCartByUserId(userId);
            if (cart == null) {
                return CartResponse.error(CartConstants.ERROR_CART_NOT_EXISTS);
            }
            return CartResponse.success(CartConstants.SUCCESS_QUERY_CART, cart.getCartId());
        } catch (Exception e) {
            log.error("查询购物车ID时发生异常：{}", e.getMessage(), e);
            return CartResponse.error(CartConstants.ERROR_SERVER + e.getMessage());
        }
    }

    @Override
    public CartResponse<String> addItemToCart(int userId, int productId, int quantity) {
        try {
            Carts cart = getCartByUserId(userId);
            if (cart == null) {
                return CartResponse.error(CartConstants.ERROR_CART_NOT_EXISTS);
            }

            CartItems existingItem = cartItemsMapper.selectOne(
                    new LambdaQueryWrapper<CartItems>()
                            .eq(CartItems::getCartId, cart.getCartId())
                            .eq(CartItems::getProductId, productId)
            );

            if (existingItem != null) {
                return CartResponse.error(CartConstants.ERROR_ITEM_EXISTS);
            }

            CartItems newItem = new CartItems();
            newItem.setCartId(cart.getCartId());
            newItem.setProductId(productId);
            newItem.setQuantity(quantity);

            int rows = cartItemsMapper.insert(newItem);
            if (rows <= 0) {
                return CartResponse.error(CartConstants.ERROR_CREATE_CART);
            }

            return CartResponse.success(CartConstants.SUCCESS_ADD_ITEM, "商品已添加到购物车");
        } catch (Exception e) {
            log.error("添加商品到购物车时发生异常：{}", e.getMessage(), e);
            return CartResponse.error(CartConstants.ERROR_SERVER + e.getMessage());
        }
    }

    @Override
    public CartResponse<CartDTO> getCartContent(int userId) {
        try {
            Carts cart = getCartByUserId(userId);
            if (cart == null) {
                return CartResponse.error(CartConstants.ERROR_CART_NOT_EXISTS);
            }

            List<CartItems> items = cartItemsMapper.selectList(
                    new LambdaQueryWrapper<CartItems>()
                            .eq(CartItems::getCartId, cart.getCartId())
            );

            CartDTO cartDTO = new CartDTO();
            cartDTO.setCartId(cart.getCartId());
            cartDTO.setUserId(cart.getUserId());
            cartDTO.setCreatedAt(cart.getCreatedAt());
            cartDTO.setUpdatedAt(cart.getUpdatedAt());
            cartDTO.setItems(items);

            return CartResponse.success(CartConstants.SUCCESS_GET_CART, cartDTO);
        } catch (Exception e) {
            log.error("获取购物车内容时发生异常：{}", e.getMessage(), e);
            return CartResponse.error(CartConstants.ERROR_SERVER + e.getMessage());
        }
    }

    @Override
    public CartResponse<String> updateItemQuantity(int userId, int productId, int quantity) {
        try {
            Carts cart = getCartByUserId(userId);
            if (cart == null) {
                return CartResponse.error(CartConstants.ERROR_CART_NOT_EXISTS);
            }

            CartItems item = cartItemsMapper.selectOne(
                    new LambdaQueryWrapper<CartItems>()
                            .eq(CartItems::getCartId, cart.getCartId())
                            .eq(CartItems::getProductId, productId)
            );

            if (item == null) {
                return CartResponse.error(CartConstants.ERROR_ITEM_NOT_EXISTS);
            }

            item.setQuantity(quantity);
            int rows = cartItemsMapper.updateById(item);
            if (rows <= 0) {
                return CartResponse.error(CartConstants.ERROR_UPDATE_QUANTITY);
            }

            return CartResponse.success(CartConstants.SUCCESS_UPDATE_QUANTITY, "商品数量已更新");
        } catch (Exception e) {
            log.error("更新购物车商品数量时发生异常：{}", e.getMessage(), e);
            return CartResponse.error(CartConstants.ERROR_SERVER + e.getMessage());
        }
    }

    @Override
    public CartResponse<String> deleteItemFromCart(int userId, int productId) {
        try {
            Carts cart = getCartByUserId(userId);
            if (cart == null) {
                return CartResponse.error(CartConstants.ERROR_CART_NOT_EXISTS);
            }

            CartItems item = cartItemsMapper.selectOne(
                    new LambdaQueryWrapper<CartItems>()
                            .eq(CartItems::getCartId, cart.getCartId())
                            .eq(CartItems::getProductId, productId)
            );

            if (item == null) {
                return CartResponse.error(CartConstants.ERROR_ITEM_NOT_EXISTS);
            }

            int rows = cartItemsMapper.deleteById(item.getItemId());
            if (rows <= 0) {
                return CartResponse.error(CartConstants.ERROR_DELETE_ITEM);
            }

            return CartResponse.success(CartConstants.SUCCESS_DELETE_ITEM, "商品已从购物车中删除");
        } catch (Exception e) {
            log.error("删除购物车商品时发生异常：{}", e.getMessage(), e);
            return CartResponse.error(CartConstants.ERROR_SERVER + e.getMessage());
        }
    }

    /**
     * 删除购物车中所有商品
     *
     * @param userId 用户 ID
     * @return {@link CartResponse }<{@link String }>
     * @author 小粥
     * @since 2025/03/03
     */
    @Override
    public CartResponse<String> deleteAllItemsFromCart(int userId) {
        try {
            Carts cart = getCartByUserId(userId);
            if (cart == null) {
                return CartResponse.error(CartConstants.ERROR_CART_NOT_EXISTS);
            }

            int rows = cartItemsMapper.delete(
                    new LambdaQueryWrapper<CartItems>()
                            .eq(CartItems::getCartId, cart.getCartId())
            );

            log.info("用户 {} 的购物车中删除了 {} 条商品项", userId, rows);
            return CartResponse.success(CartConstants.SUCCESS_DELETE_ITEM, "购物车中所有商品已删除");
        } catch (Exception e) {
            log.error("删除购物车所有商品时发生异常：{}", e.getMessage(), e);
            return CartResponse.error(CartConstants.ERROR_SERVER + e.getMessage());
        }
    }
}